Project Part 4¶
- Importing Necessary modules
In [1]:
import os
import numpy as np
import pandas as pd
import cv2
import matplotlib.pyplot as plt
%matplotlib inline
import warnings
warnings.filterwarnings('ignore')
from sklearn.model_selection import train_test_split
import itertools
from keras.preprocessing import image
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import ReduceLROnPlateau
from keras.models import Sequential, Model
from keras.layers import Dense, Activation, Flatten, Dropout, concatenate, Input, Conv2D, MaxPooling2D
from keras.optimizers import Adam, Adadelta
from keras.layers.advanced_activations import LeakyReLU
from keras.utils.np_utils import to_categorical
import glob
In [2]:
from sklearn.metrics import classification_report
In [3]:
!pip install tflearn
import tflearn.datasets.oxflower17 as oxflower17
- Initializing Image height/width/size/epochs as we are using it in multiple places
In [4]:
img_height=100
img_width=100
batch_size=32
nb_epochs=25
In [5]:
#Using data present in local folder
Loading Data¶
Exploring the folders containing data¶
In [7]:
def get_immediate_subdirectories(a_dir):
return [name for name in os.listdir(a_dir)
if os.path.isdir(os.path.join(a_dir, name))]
In [8]:
specPath='F:\\GreatLearning\AI\\ComputerVision\\Project\\Flowers-Classification\\17flowers-train\\jpg'
specPathTest='F:\\GreatLearning\\AI\\ComputerVision\\Project\\Flowers-Classification\\Test\\'
cat_Folder_list=get_immediate_subdirectories(specPath)
List of species in the train folders¶
In [9]:
Flower_species=cat_Folder_list
print('List of Flower species: ', Flower_species)
- we have 17 species of flowers tagged with numbers from 0 to 16
Nummber of images in the train sub folders along with categories¶
In [10]:
#No. of images under each plant species foler for train
for img in Flower_species:
print('{} --> {} training images'.format(img, len(os.listdir(os.path.join(specPath, img)))))
- There are 17 species are available for training and each flower species contains 80-85 images
In [11]:
import glob
rootdir='F:\\GreatLearning\\AI\\ComputerVision\\Project\\'
rootJPG=os.path.join(os.path.join(rootdir,'Flowers-Classification\\17flowers-train'),'jpg')
os.chdir(os.path.join(specPath,Flower_species[0])) #changing current directory to open file easily
count=0
imgList=[]
for file in glob.glob("*.jpg"):
print(file)
count+=1
imgList.append(file)
if (count==10):
break
Data visualisation:¶
In [12]:
from PIL import Image
Image.open("image_0002.jpg")
Out[12]:
In [13]:
import imageio
import matplotlib.pyplot as plt
%matplotlib inline
#capture basic details of images
def imgBasics(path,imgName):
img1= os.path.join(path, imgName)
pic = imageio.imread(img1)
plt.figure(figsize = (5,5))
plt.imshow(pic)
#Basic properties of image
print('Type of the image : ' , type(pic))
print('Shape of the image : {}'.format(pic.shape))
print('Image Hight {}'.format(pic.shape[0]))
print('Image Width {}'.format(pic.shape[1]))
print('Dimension of Image {}'.format(pic.ndim))
print('Image size {}'.format(pic.size))
print('Maximum RGB value in this image {}'.format(pic.max()))
print('Minimum RGB value in this image {}'.format(pic.min()))
print('Value of only R channel {}'.format(pic[ 100, 50, 0]))
print('Value of only G channel {}'.format(pic[ 100, 50, 1]))
print('Value of only B channel {}'.format(pic[ 100, 50, 2]))
In [14]:
firstSpecies=os.path.join(specPath,Flower_species[0])
imgBasics(firstSpecies,imgList[0])
In [15]:
imgBasics(firstSpecies,imgList[1])
In [16]:
imgBasics(firstSpecies,imgList[9])
In [17]:
imgBasics(firstSpecies,imgList[5])
- From the above observed images, each image has same height but diff width
- We can see the color composition are diff
- images were taken at different light conditions
- images were taken at different angles as well
- not all images are center weighted, few have multiple images as well
- For color concentratin as well, we can notice the distribution is spreaded on R,G & B.
- Lot of baackground information is also present including the leaves or trees or presence of other objects as well
In [30]:
rootdir='F:\\GreatLearning\\AI\\ComputerVision\\Project\\'
os.chdir(rootdir) #resetting back to original directory
In [ ]:
Loading data from all folders along with mapped categories¶
In [13]:
import glob
images_per_class = {}
for class_folder_name in os.listdir(specPath):
class_folder_path = os.path.join(specPath, class_folder_name)
if os.path.isdir(class_folder_path):
class_label = class_folder_name
images_per_class[class_label] = []
for image_path in glob.glob(os.path.join(class_folder_path, "*.jpg")):
img = cv2.imread(image_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
#image_bgr = cv2.imread(image_path, cv2.IMREAD_COLOR)
images_per_class[class_label].append(img)
In [12]:
for key,value in images_per_class.items():
print("{0} -> {1}".format(key, len(value)))
Plot images¶
Plot images so we can see what the input looks like
In [20]:
#Function for getting images class wise
def plot_for_class(label):
nb_rows = 3
nb_cols = 3
fig, axs = plt.subplots(nb_rows, nb_cols, figsize=(6, 6))
n = 0
for i in range(0, nb_rows):
for j in range(0, nb_cols):
axs[i, j].xaxis.set_ticklabels([])
axs[i, j].yaxis.set_ticklabels([])
axs[i, j].imshow(images_per_class[label][n])
n += 1
In [21]:
plot_for_class("0")
In [22]:
plot_for_class("1")
In [23]:
plot_for_class("6")
In [24]:
len(images_per_class['0'])
Out[24]:
- Getting radom images from all classes
In [25]:
import random as rn
Z=images_per_class
fig,ax=plt.subplots(5,5)
fig.set_size_inches(15,15)
for i in range(5):
for j in range (5):
l=rn.randint(0,len(Z)-1)
#print(l)
k=rn.randint(0,len(Z[str(l)])-1)
#print(k)
ax[i,j].imshow(Z[str(l)][k])
ax[i,j].set_title('Flower: '+str(l))
plt.tight_layout()
In [ ]:
- From above groups of images we can observe there is huge variation in data set
- There is a wide mix of similar feature among classes as well, like class 9,11,12 look a lot similar
- If we notice Flowe class 2 in above image, flowers are very less compared to the bigger leaves it contains
- Many of the images are center weighted and are good for details, but many of them has huge variations or very less presence of the image compared to overall image.
- Color distribution is very dynamic among classes.
In [ ]:
Apply different filters¶
- Creating functions for mask to observe the features
Reference:
Edge Detection masks were created below
In [30]:
image = images_per_class["1"][8]
plt.imshow(image, cmap='gray')
# 3x3 sobel filter for horizontal edge detection
sobel_y = np.array([[ -1, -2, -1],
[ 0, 0, 0],
[ 1, 2, 1]])
# vertical edge detection
sobel_x = np.array([[-1, 0, 1],
[-2, 0, 2],
[-1, 0, 1]])
# filter the image using filter2D(grayscale image, bit-depth, kernel)
filtered_image1 = cv2.filter2D(image, -1, sobel_x)
filtered_image2 = cv2.filter2D(image, -1, sobel_y)
f, ax = plt.subplots(1, 2, figsize=(15, 4))
ax[0].set_title('horizontal edge detection')
ax[0].imshow(filtered_image1, cmap='gray')
ax[1].set_title('vertical edge detection')
ax[1].imshow(filtered_image2, cmap='gray')
Out[30]:
In [31]:
image = images_per_class["0"][8]
plt.imshow(image, cmap='gray')
# 3x3 sobel filter for horizontal edge detection
sobel_y = np.array([[ -1, -2, -1],
[ 0, 0, 0],
[ 1, 2, 1]])
# vertical edge detection
sobel_x = np.array([[-1, 0, 1],
[-2, 0, 2],
[-1, 0, 1]])
# filter the image using filter2D(grayscale image, bit-depth, kernel)
filtered_image1 = cv2.filter2D(image, -1, sobel_x)
filtered_image2 = cv2.filter2D(image, -1, sobel_y)
f, ax = plt.subplots(1, 2, figsize=(15, 4))
ax[0].set_title('horizontal edge detection')
ax[0].imshow(filtered_image1, cmap='gray')
ax[1].set_title('vertical edge detection')
ax[1].imshow(filtered_image2, cmap='gray')
Out[31]:
In [32]:
image = images_per_class["0"][8]
# 3x3 sobel filter for horizontal edge detection
sobel_y = np.array([[ 0, -1, 0],
[ -1, 5, -1],
[ 0, -1, 0]])
# vertical edge detection
sobel_x = np.array([[ 0, -1, 0],
[ -1, 5, -1],
[ 0, -1, 0]])
# filter the image using filter2D(grayscale image, bit-depth, kernel)
filtered_image1 = cv2.filter2D(image, -1, sobel_x,sobel_y)
plt.imshow(filtered_image1)
Out[32]:
In [26]:
def create_mask_for_plant(image):
image_hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
sensitivity = 35
lower_hsv = np.array([60 - sensitivity, 100, 50])
upper_hsv = np.array([60 + sensitivity, 255, 255])
mask = cv2.inRange(image_hsv, lower_hsv, upper_hsv)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11,11))
mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
return mask
def segment_plant(image):
mask = create_mask_for_plant(image)
output = cv2.bitwise_and(image, image, mask = mask)
return output
def sharpen_image(image):
image_blurred = cv2.GaussianBlur(image, (0, 0), 3)
image_sharp = cv2.addWeighted(image, 1.5, image_blurred, -0.5, 0)
return image_sharp
In [ ]:
In [27]:
image = images_per_class["9"][65]
image_mask = create_mask_for_plant(image)
image_segmented = segment_plant(image)
image_sharpen = sharpen_image(image_segmented)
fig, axs = plt.subplots(1, 4, figsize=(20, 20))
axs[0].imshow(image)
axs[1].imshow(image_mask)
axs[2].imshow(image_segmented)
axs[3].imshow(image_sharpen)
Out[27]:
In [28]:
image = images_per_class["0"][65]
image_mask = create_mask_for_plant(image)
image_segmented = segment_plant(image)
image_sharpen = sharpen_image(image_segmented)
fig, axs = plt.subplots(1, 4, figsize=(20, 20))
axs[0].imshow(image)
axs[1].imshow(image_mask)
axs[2].imshow(image_segmented)
axs[3].imshow(image_sharpen)
Out[28]:
In [29]:
image = images_per_class["1"][8]
image_mask = create_mask_for_plant(image)
image_segmented = segment_plant(image)
image_sharpen = sharpen_image(image_segmented)
fig, axs = plt.subplots(1, 4, figsize=(20, 20))
axs[0].imshow(image)
axs[1].imshow(image_mask)
axs[2].imshow(image_segmented)
axs[3].imshow(image_sharpen)
Out[29]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
- Importing data
- Preprocessing the image for using it in models
- For Supervised Models like KNN,
- importing and resizing it to 32x32 with RGB to maintain its colours and pattern (COLOR_BGR2RGB)
- For Interpolation using cv.INTER_AREA
- dividing the values with 255 to normalize it and make it float
- capturing the folder names as categories
In [14]:
#we can not directly use the image, we have to process the image.
from pathlib import Path
from skimage.io import imread
from keras.preprocessing import image
import cv2 as cv
def load_image_files(container_path):
image_dir = Path(container_path)
folders = [directory for directory in image_dir.iterdir() if directory.is_dir()]
categories = [fo.name for fo in folders]
images = []
flat_data = []
target = []
count = 0
train_img = []
label_img = []
for i, direc in enumerate(folders):
for file in direc.iterdir():
count += 1
img = imread(file)
#img = cv.cvtColor(img, cv.COLOR_BGR2RGB)
img_pred = cv.resize(img, (img_height, img_width), interpolation=cv.INTER_AREA)
img_pred = image.img_to_array(img_pred)
img_pred = img_pred / 255
train_img.append(img_pred)
label_img.append(categories[i])
X = np.array(train_img)
y = np.array(label_img)
return X,y
#Using the Keras pre-processing library the image is converted to an array and then normalised.
In [15]:
X = []
y = []
X,y = load_image_files(specPath)
In [ ]:
Exploring shape of imported data¶
In [16]:
X.shape
Out[16]:
In [17]:
y.shape
Out[17]:
Exploring images captured¶
In [18]:
y[0]
Out[18]:
In [19]:
plt.imshow(X[0])
plt.show()
In [20]:
plt.imshow(X[1],cmap='gist_earth')
plt.show()
In [21]:
fig=plt.figure(figsize=(15,15))
for i in range(1,101):
img=X[i]
fig.add_subplot(10,10,i)
plt.imshow(img,cmap='gray')
plt.show()
print('Label: ', y[1:101])
In [22]:
fig=plt.figure(figsize=(15,15))
for i in range(1,101):
img=X[1000+i]
fig.add_subplot(10,10,i)
plt.imshow(img)
plt.show()
print('Label: ', y[1001:1101])
Image analysis¶
- Images are not simple
- Contains foreground and background details with multiple objects as noise in it like trees, big leaves, bees etc
- Huge variations of data present
- Images are not focused as well
- Actual flowers are covering very less pixels compared to background and noise. This will lead to high class imbalance for target object and noise.
- Simple supervised models will have hard time filtering the actual plants with soil and stones as they see the whole picture as a single input and are not splitting foreground from background.
Creating data sets for training and testing¶
- Splitting Whole data set to Train, Val and Test with 80%, 10%, 10% respectively
In [23]:
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)
In [24]:
X_val, X_test, y_val, y_test = train_test_split(X_test, y_test, random_state=42, test_size=0.5)
In [25]:
#View data set shape
print("X_train: "+str(X_train.shape))
print("X_test: "+str(X_test.shape))
print("X_val: "+str(X_val.shape))
print("y_train: "+str(y_train.shape))
print("y_test: "+str(y_test.shape))
print("y_val: "+str(y_val.shape))
In [ ]:
In [ ]:
In [26]:
#View Raw data in train set
X_train[0]
Out[26]:
In [27]:
#Reshaping Data sets for using in KNN model
from builtins import range
from builtins import object
num_training = X_train.shape[0]
mask = list(range(num_training))
X_train = X_train[mask]
y_train = y_train[mask]
num_test = X_test.shape[0]
mask = list(range(num_test))
X_test = X_test[mask]
y_test = y_test[mask]
num_val = X_val.shape[0]
mask = list(range(num_val))
X_val = X_val[mask]
y_val = y_val[mask]
# Reshape the image data into rows
X_train = np.reshape(X_train, (X_train.shape[0], -1))
X_test = np.reshape(X_test, (X_test.shape[0], -1))
X_val = np.reshape(X_val, (X_val.shape[0], -1))
print("X_train: "+str(X_train.shape))
print("X_test: "+str(X_test.shape))
print("X_val: "+str(X_val.shape))
print("y_train: "+str(y_train.shape))
print("y_test: "+str(y_test.shape))
print("y_val: "+str(y_val.shape))
In [47]:
print(y.view())
In [ ]:
Image classification with KNN¶
KNN¶
- For Flower species raw data, expectations is the flower patern remain close to each other and a KNN model will be able pick up the common features and group it together
- k-nearest neighbor algorithm is for classifying objects based on closest training examples in the feature space. k-nearest neighbor algorithm is among the simplest of all machine learning algorithms. Training process for this algorithm only consists of storing feature vectors and labels of the training images. In the classification process, the unlabelled query point is simply assigned to the label of its k nearest neighbors.
- A main advantage of the KNN algorithm is that it performs well with multi-modal classes because the basis of its decision is based on a small neighborhood of similar objects. Therefore, even if the target class is multi-modal, the algorithm can still lead to good accuracy.
In [48]:
from sklearn.metrics import accuracy_score,confusion_matrix,recall_score,f1_score,precision_score,roc_curve,log_loss,auc
from sklearn.neighbors import KNeighborsClassifier
#KNN Model with 1 neighbour
KnnModel = KNeighborsClassifier(n_neighbors=1)
KnnModel.fit(X_train,y_train)
y_predict=KnnModel.predict(X_test)
In [49]:
print('Accuracy score:',accuracy_score(y_test,y_predict))
print('confuion matrix:\n',confusion_matrix(y_test,y_predict))
- With single neighbour we are able to acheive close to 30% accuracy, but 1 neighbour is higly volatile and wont give us generalised result
In [50]:
# Initializing the value of k and finding the accuracies on validation data
k_vals = range(1, 30, 2)
accuracies = []
for k in range(1, 30, 2):
knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(X_train, y_train)
score = knn.score(X_val, y_val)
print("k value=%d, accuracy score=%.2f%%" % (k, score * 100))
accuracies.append(score)
# finding the value of k which has the largest accuracy
i = int(np.argmax(accuracies))
print("k=%d value has highest accuracy of %.2f%% on validation data" % (k_vals[i],accuracies[i] * 100))
- Even though we got highest accuracies at 1 neighbour but we will go ahead with k=7 for more generalized approach which showed similar high accuracies on validation data set.
In [51]:
knn = KNeighborsClassifier(n_neighbors=7)
knn.fit(X_train, y_train)
predictions = knn.predict(X_test)
In [52]:
print("EVALUATION ON TESTING DATA")
print(confusion_matrix(y_test,predictions))
print(knn.score(X_test, y_test))
In [53]:
plt.figure(figsize=(2,2))
plt.imshow(X_test[59].reshape(img_height,img_width,3))
plt.show()
image = X_test[59]
print('Prediction:',knn.predict(image.reshape(1, -1)))
print('Actual:',y_test[59])
In [54]:
plt.figure(figsize=(2,2))
plt.imshow(X_test[30].reshape(img_height,img_width,3))
plt.show()
image = X_test[30]
print('Prediction:',knn.predict(image.reshape(1, -1)))
print('Actual:',y_test[30])
In [55]:
predictions = knn.predict(X_test)
print(classification_report(y_test, predictions))
In [56]:
print(knn.score(X_test, y_test))
- Accuracies from KNN are close to 23%.
- We can observe on each classes precision and recall are very low.
- Model is not able to identify and split relevent data from rest of the noise.
- For flower species, expectations is the flower patern remain close to each other and a KNN model will be able pick up the common features and group it together.
- While data analysis we noticed the images contains lot of noise or in few images actual flower is hardly cvering 5% of total pixels
- Executed KNN from 1 to 30 neighbours and identified best values were at 1 neighbour and 25 neighbours. We chose for 7 neighbours so that we will get a more generalized prediction on classification.
- With KNN our classification accuracies were close to 23% which are way below acceptable levels
- Images with different angles are also getting mixed up with similar flower class creating a difference in prediction for KNN
- We can observe there is an underlying pattern to the images for both raw pixel intensities and color. KNN is not capable enough to understand the differences and classifymore accurately.
In [ ]:
Issues with KNN¶
- KNN depends on nearest neighbours, which might not be the best choice all the time. Observed the same issue during our evaluation proces as well
- a major disadvantage of the KNN algorithm is that it uses all the features equally in computing for similarities. This can lead to classification errors, especially when there is only a small subset of features that are useful for classification.
In [ ]:
In [ ]:
In [ ]:
In [ ]:
Image classification with Neural Network¶
In [57]:
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)
In [58]:
X_val, X_test, y_val, y_test = train_test_split(X_test, y_test, random_state=42, test_size=0.5)
In [ ]:
- Using One hot encoder to convert the categories to array formats
In [59]:
#from tensorflow.keras.utils import to_categorical
from sklearn.preprocessing import OneHotEncoder
one_hot_encoder = OneHotEncoder(sparse=False)
one_hot_encoder.fit(y_train.reshape(-1, 1))
y_train = one_hot_encoder.transform(y_train.reshape(-1, 1))
#y_train = pd.DataFrame(data=y_train, columns=one_hot_encoder.categories_)
y_test = one_hot_encoder.transform(y_test.reshape(-1, 1))
#y_test = pd.DataFrame(data=y_test, columns=one_hot_encoder.categories_)
y_val = one_hot_encoder.transform(y_val.reshape(-1, 1))
#y_val = pd.DataFrame(data=y_val, columns=one_hot_encoder.categories_)
print("Shape of y_train:", y_train.shape)
print("Shape of y_test:", y_test.shape)
print("Shape of y_val:", y_val.shape)
In [60]:
y_train
Out[60]:
In [61]:
y_test_cat = pd.DataFrame(data=y_test, columns=one_hot_encoder.categories_)
In [62]:
y_test_cat
Out[62]:
In [63]:
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense, Activation
from tensorflow.keras import optimizers
from tensorflow.keras.layers import BatchNormalization, Dropout
In [ ]:
In [ ]:
- created NN with less complexity as the results remained close and to reduce execution time as well
In [65]:
model = Sequential()
model.add(Flatten())
model.add(Dense(1000,kernel_initializer='he_normal'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dense(500,kernel_initializer='he_normal'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dense(250,kernel_initializer='he_normal'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dense(125,kernel_initializer='he_normal'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dense(34,kernel_initializer='he_normal'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dense(17,kernel_initializer='he_normal'))
model.add(Activation('softmax'))
#updating learning rate
adam = optimizers.Adam(lr=0.009, decay=1e-6)
# Compile the model
model.compile(loss="categorical_crossentropy", metrics=["accuracy"], optimizer="adam")
# Fit the model
history=model.fit(x=X_train, y=y_train, batch_size=batch_size, epochs=nb_epochs, validation_data=(X_val, y_val))
In [66]:
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'r', label='Training accuracy')
plt.plot(epochs, val_acc, 'b', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend(loc=0)
plt.figure()
plt.show()
- We can notice the train accuracies are increasing close to 100% but validation accuracies are around 40% only
- We will try to augment the train data and train it again so that we will get less overfitted model
In [67]:
results = model.evaluate(X_test, y_test)
print('Accuracy: %f ' % (results[1]*100))
print('Loss: %f' % results[0])
Y_pred_test_cls = (model.predict(X_test) > 0.5).astype("int32")
plt.figure(figsize=(2,2))
plt.imshow(X_test[10].reshape(img_height,img_width,3))
plt.show()
print('Label - one hot encoded: \n',y_test_cat.iloc[10] )
print('Actual Label - one hot encoded: ', y_test[10])
print('Predicted Label - one hot encoded: ',Y_pred_test_cls[10] )
- Test data set accuracies are around 40%
In [ ]:
- With Neural network we were able to improve test set predictions to close to 40%.
- Even with NN we are struggling for image identification with high accuracies.
- Epochs were limited at 25 only as we will be comparing the same with CNN on similar grounds. We may acheive a bit higher accuracies with more epochs.
- NN is able to provide better result compared to KNN.
In [ ]:
In [ ]:
In [ ]:
Image Classification with CNN¶
In [28]:
from tensorflow.keras.models import Sequential # initial NN
from tensorflow.keras.layers import Dense, Dropout # construct each layer
from tensorflow.keras.layers import Conv2D # swipe across the image by 1
from tensorflow.keras.layers import MaxPooling2D # swipe across by pool size
from tensorflow.keras.layers import Flatten, GlobalAveragePooling2D
from tensorflow import keras
In [29]:
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)
X_val, X_test, y_val, y_test = train_test_split(X_test, y_test, random_state=42, test_size=0.5)
In [30]:
#from tensorflow.keras.utils import to_categorical
from sklearn.preprocessing import OneHotEncoder
one_hot_encoder = OneHotEncoder(sparse=False)
one_hot_encoder.fit(y_train.reshape(-1, 1))
y_train = one_hot_encoder.transform(y_train.reshape(-1, 1))
#y_train = pd.DataFrame(data=y_train, columns=one_hot_encoder.categories_)
y_test = one_hot_encoder.transform(y_test.reshape(-1, 1))
#y_test = pd.DataFrame(data=y_test, columns=one_hot_encoder.categories_)
y_val = one_hot_encoder.transform(y_val.reshape(-1, 1))
#y_val = pd.DataFrame(data=y_val, columns=one_hot_encoder.categories_)
print("Shape of y_train:", y_train.shape)
print("Shape of y_test:", y_test.shape)
print("Shape of y_val:", y_val.shape)
In [31]:
y_train
Out[31]:
In [32]:
y_test_cat = pd.DataFrame(data=y_test, columns=one_hot_encoder.categories_)
In [33]:
y_test_cat
Out[33]:
In [ ]:
In [74]:
model = Sequential()
model.add(Conv2D(64, (5, 5), activation='relu', input_shape=(img_height, img_width, 3)))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(17, activation='softmax'))
model.summary()
# compile model
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
history=model.fit(x=X_train, y=y_train, batch_size=batch_size, epochs=nb_epochs, validation_data=(X_val, y_val))
history
Out[74]:
In [75]:
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'r', label='Training accuracy')
plt.plot(epochs, val_acc, 'b', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend(loc=0)
plt.figure()
plt.show()
- With a very basic CNN model also we can see the validation accuracies are close to 52%
In [76]:
results = model.evaluate(X_test, y_test)
print('Accuracy: %f ' % (results[1]*100))
print('Loss: %f' % results[0])
Y_pred_test_cls = (model.predict(X_test) > 0.5).astype("int32")
plt.figure(figsize=(2,2))
plt.imshow(X_test[30].reshape(img_height,img_width,3))
plt.show()
print('Label - one hot encoded: \n',y_test_cat.iloc[30] )
print('Actual Label - one hot encoded: ', y_test[30])
print('Predicted Label - one hot encoded: ',Y_pred_test_cls[30] )
- Adding few additional layers in model for it to capture more features
In [78]:
model = Sequential()
model.add(Conv2D(100, (5, 5), activation='relu', input_shape=(img_height, img_width, 3)))
model.add(MaxPooling2D((2, 2)))
model.add(BatchNormalization())
model.add(Conv2D(filters=128, kernel_size=4, padding='same', activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(BatchNormalization())
model.add(Conv2D(filters=128, kernel_size=3, padding='same', activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.4))
model.add(Conv2D(filters=256, kernel_size=3, padding='same', activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(17, activation='softmax'))
model.summary()
#updating learning rate
adam = optimizers.Adam(lr=0.009, decay=1e-6)
# compile model
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
#Saving the best model using model checkpoint callback
model_checkpoint=keras.callbacks.ModelCheckpoint('Flowerspecies_CNN_model.h5', #where to save the model
save_best_only=True,
monitor='val_accuracy',
mode='max',
verbose=1)
history=model.fit(x=X_train, y=y_train,
batch_size=batch_size,
epochs=nb_epochs,
validation_data=(X_val, y_val))
#callbacks = [model_checkpoint])
history
Out[78]:
In [79]:
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'r', label='Training accuracy')
plt.plot(epochs, val_acc, 'b', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend(loc=0)
plt.figure()
plt.show()
- We can observe now the validation accuracies are increased closed to 60%
- still there is a noticable gap betweeen train and validation accuracies, will try to close the gap in further models
In [80]:
results = model.evaluate(X_test, y_test)
print('Accuracy: %f ' % (results[1]*100))
print('Loss: %f' % results[0])
- Test data set accuracies are immproved closed to 60%¶
In [ ]:
In [ ]:
In [ ]:
In [ ]:
Always save the model and its weights after training
In [81]:
model.save('./Flower_Species_Classifier_CNN.h5')
model.save_weights('./Flower_Species_Classifier_weights_CNN.h5')
- Usinng Image Generator to increase and improve the data set to add varations
In [37]:
datagen= keras.preprocessing.image.ImageDataGenerator(rotation_range=30,
width_shift_range=0.3,
height_shift_range=0.3,
zoom_range=[0.4,1.5],
horizontal_flip=True,
vertical_flip=True)
datagen.fit(X_train)
In [87]:
model = Sequential()
model.add(Conv2D(100, (5, 5), activation='relu', input_shape=(img_height, img_width, 3)))
model.add(MaxPooling2D((2, 2)))
model.add(BatchNormalization())
model.add(Conv2D(filters=128, kernel_size=4, padding='same', activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(BatchNormalization())
model.add(Conv2D(filters=128, kernel_size=3, padding='same', activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.4))
model.add(Conv2D(filters=256, kernel_size=3, padding='same', activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.4))
model.add(Flatten())
model.add(Dense(17, activation='softmax'))
model.summary()
#updating learning rate
adam = optimizers.Adam(lr=0.001, decay=1e-6)
# compile model
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
#Saving the best model using model checkpoint callback
model_checkpoint=keras.callbacks.ModelCheckpoint('Flowerspecies_CNN_model.h5', #where to save the model
save_best_only=True,
monitor='val_accuracy',
mode='max',
verbose=1)
history= model.fit_generator(datagen.flow(X_train, y_train, batch_size=32),
epochs=nb_epochs,
validation_data=(X_val, y_val))
#callbacks = [model_checkpoint])
history
Out[87]:
In [88]:
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'r', label='Training accuracy')
plt.plot(epochs, val_acc, 'b', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend(loc=0)
plt.figure()
plt.show()
In [89]:
results = model.evaluate(X_test, y_test)
print('Accuracy: %f ' % (results[1]*100))
print('Loss: %f' % results[0])
In [90]:
model.save('./Flower_Species_Classifier_CNN_Augmented.h5')
model.save_weights('./Flower_Species_Classifier_weights_CNN_Augmented.h5')
In [91]:
#100 epochs
In [93]:
history= model.fit_generator(datagen.flow(X_train, y_train, batch_size=32),
epochs=100,
validation_data=(X_val, y_val))
#callbacks = [model_checkpoint])
history
Out[93]:
In [94]:
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'r', label='Training accuracy')
plt.plot(epochs, val_acc, 'b', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend(loc=0)
plt.figure()
plt.show()
In [95]:
results = model.evaluate(X_test, y_test)
print('Accuracy: %f ' % (results[1]*100))
print('Loss: %f' % results[0])
In [ ]:
In [96]:
model.save('./Flower_Species_Classifier_CNN_Augmented_100.h5')
model.save_weights('./Flower_Species_Classifier_weights_CNN_Augmented_100.h5')
- With CNN we have noticed the simplest CNN is able to outperform NN.
- Adding additional layers and using ImageGenerator for augmenting images gives a boost to the accuracies and it has increased the accuracies to 71%
In [ ]:
In [ ]:
In [ ]:
Transfer Learning¶
- Reimporting Data and creatinng data set as jupyter notebook was crashing for whole execution in a single go
In [34]:
from keras.applications import VGG16
#Load the VGG model
vgg_conv = VGG16(weights='F:/GreatLearning/AI/ComputerVision/week 2/Week 2 - CV - Mentor deck/Case study/data/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5',
include_top=False,
input_shape=(img_height, img_width, 3))
In [ ]:
Re importing data¶
- Attempted to reimport data with 224x224x3 and do the model prep but my local system is not able to handle it and hence reduced it back to 100 again
In [74]:
#we can not directly use the image, we have to process the image.
img_height=100
img_width=100
image_size=100
specPath='F:\\GreatLearning\AI\\ComputerVision\\Project\\Flowers-Classification\\17flowers-train\\jpg'
#we can not directly use the image, we have to process the image.
from pathlib import Path
from skimage.io import imread
from keras.preprocessing import image
import cv2 as cv
def load_image_files(container_path):
image_dir = Path(container_path)
folders = [directory for directory in image_dir.iterdir() if directory.is_dir()]
categories = [fo.name for fo in folders]
images = []
flat_data = []
target = []
count = 0
train_img = []
label_img = []
for i, direc in enumerate(folders):
for file in direc.iterdir():
count += 1
img = imread(file)
#img = cv.cvtColor(img, cv.COLOR_BGR2RGB)
img_pred = cv.resize(img, (img_height, img_width), interpolation=cv.INTER_AREA)
img_pred = image.img_to_array(img_pred)
#img_pred = img_pred / 255
train_img.append(img_pred)
label_img.append(categories[i])
X = np.array(train_img)
y = np.array(label_img)
return X,y
In [75]:
vggX = []
vggy = []
vggX,vggy = load_image_files(specPath)
In [ ]:
Exploring shape of imported data¶
In [76]:
vggX.shape
Out[76]:
In [77]:
vggy.shape
Out[77]:
In [78]:
vggy = np.asarray(vggy).reshape(vggy.shape[0],1)
In [79]:
vggy.shape
Out[79]:
In [80]:
#from tensorflow.keras.utils import to_categorical
from sklearn.preprocessing import OneHotEncoder
one_hot_encoder = OneHotEncoder(sparse=False)
one_hot_encoder.fit(vggy.reshape(-1, 1))
vggy = one_hot_encoder.transform(vggy.reshape(-1, 1))
print("Shape of y:", vggy.shape)
In [81]:
vggX_train, vggX_test,vggy_train, vggy_test = train_test_split(vggX, vggy, random_state=42, test_size=0.2)
In [82]:
vggX_val, vggX_test, vggy_val, vggy_test = train_test_split(vggX_test, vggy_test, random_state=42, test_size=0.5)
In [83]:
#View data set shape
print("X_train: "+str(vggX_train.shape))
print("X_test: "+str(vggX_test.shape))
print("X_val: "+str(vggX_val.shape))
print("y_train: "+str(vggy_train.shape))
print("y_test: "+str(vggy_test.shape))
print("y_val: "+str(vggy_val.shape))
In [84]:
import matplotlib.pyplot as plt
plt.figure(figsize=(10,10)) # plot 25 images
for i in range(25):
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(vggX_train[i]/255, cmap=plt.cm.binary)
plt.xlabel(vggy_train[i])
In [142]:
# use vgg16 pre-trained model with trainable densely connected output layer
from keras.applications import VGG16
#Load the VGG model
#Loading VGG model from mentors deck as loading online was slowing things down
#Code details captured from mentor deck
vgg_conv = VGG16(weights='F:/GreatLearning/AI/ComputerVision/week 2/Week 2 - CV - Mentor deck/Case study/data/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5',
include_top=False,
input_shape=(img_height, img_width, 3)
)
# Freeze all the layers except for the last layer:
for layer in vgg_conv.layers[:-4]:
layer.trainable = False
from keras import models
from keras import layers
from keras import optimizers
# Create the model
model = models.Sequential()
# Add the vgg convolutional base model
model.add(vgg_conv)
# Add new layers
model.add(layers.Flatten())
model.add(layers.Dense(1024, activation='relu'))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(17, activation='softmax'))
model.summary()
In [143]:
# image augmentation for train set and image resizing for validation & test
from keras.preprocessing.image import ImageDataGenerator
train_datagen = ImageDataGenerator(
rescale=1./255,
rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
fill_mode='nearest')
validation_datagen = ImageDataGenerator(rescale=1./255)
train_batchsize = 100
val_batchsize = 10
train_generator = train_datagen.flow(
vggX_train,vggy_train,
batch_size=train_batchsize)
validation_generator = validation_datagen.flow(
vggX_val,vggy_val,
batch_size=val_batchsize,
shuffle=False)
test_generator = validation_datagen.flow(
vggX_test,vggy_test,
batch_size=val_batchsize,
shuffle=False)
In [ ]:
vggX_test=vggX_test/255
In [144]:
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.RMSprop(lr=2e-4),
metrics=['acc'])
In [145]:
history = model.fit_generator(
train_generator,
steps_per_epoch=vggX_train.shape[0]/train_generator.batch_size ,
epochs=nb_epochs,
validation_data=validation_generator,
validation_steps=vggX_val.shape[0]/validation_generator.batch_size)
In [146]:
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'r', label='Training accuracy')
plt.plot(epochs, val_acc, 'b', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend(loc=0)
plt.figure()
plt.show()
In [ ]:
In [147]:
results = model.evaluate(vggX_test, vggy_test)
print('Accuracy: %f ' % (results[1]*100))
print('Loss: %f' % results[0])
In [95]:
Y_pred_test_cls = (model.predict(vggX_test) > 0.5).astype("int32")
plt.figure(figsize=(2,2))
plt.imshow(vggX_test[30]/255)
plt.show()
#print('Label - one hot encoded: \n',vggy_test_cat.iloc[30] )
print('Actual Label - one hot encoded: ', vggy_test[30])
print('Predicted Label - one hot encoded: ',Y_pred_test_cls[30] )
In [96]:
model.save('./Flower_Species_Classifier_VGG16_Augmented_25.h5')
model.save_weights('./Flower_Species_Classifier_weights_VGG16_Augmented_25.h5')
- With 25 epochs we are getting a accuracy of 80% which is close to CNN's result after 100 epochs
- continue training the existing model for anothr 100 epochs and we can see immproved results
In [103]:
history = model.fit_generator(
train_generator,
steps_per_epoch=vggX_train.shape[0]/train_generator.batch_size ,
epochs=100,
validation_data=validation_generator,
validation_steps=vggX_val.shape[0]/validation_generator.batch_size)
In [104]:
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'r', label='Training accuracy')
plt.plot(epochs, val_acc, 'b', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend(loc=0)
plt.figure()
plt.show()
In [137]:
results = model.evaluate(vggX_test, vggy_test)
print('Accuracy: %f ' % (results[1]*100))
print('Loss: %f' % results[0])
In [106]:
Y_pred_test_cls = (model.predict(vggX_test) > 0.5).astype("int32")
plt.figure(figsize=(2,2))
plt.imshow(vggX_test[30]/255)
plt.show()
#print('Label - one hot encoded: \n',vggy_test_cat.iloc[30] )
print('Actual Label - one hot encoded: ', vggy_test[30])
print('Predicted Label - one hot encoded: ',Y_pred_test_cls[30] )
- With Pretrained Model we can observe the training time is reduced and accuracies are increaed to 90%
- CNN Models were better compared to NN as they are able to cpature details of foreground and background better and able to classify things.
- Our Accuracies has improved from 20% in KNN ===> 40% in NN ===> 70% in CNN ===> 90% in Pretrained Models
In [ ]:
In [ ]:
Saving Model using Keras and Pickel¶
In [107]:
model.save('./Flower_Species_Classifier_VGG16_Augmented_100.h5')
model.save_weights('./Flower_Species_Classifier_weights_VGG16_Augmented_100.h5')
In [108]:
#Keras suggests to use model.save and model.save_weights but we can pickle model using joblib as well for bigger model if usual pickling fails
from sklearn.externals import joblib
# Save the model as a pickle in a file
joblib.dump(model, 'Flower_Species_Classifier_VGG16_Augmented_100.pkl')
Out[108]:
In [109]:
# Load the model from the file
model_joblib = joblib.load('Flower_Species_Classifier_VGG16_Augmented_100.pkl')
In [ ]:
In [ ]:
In [ ]:
- Creating code to classify single image for UI
Predicting single data¶
In [129]:
#converting single image to expected format for model prediction
pred_x = np.expand_dims(vggX_test[30], axis=0)
pred_x.shape
Out[129]:
In [114]:
# Use the loaded model to make predictions
#model_joblib.predict(X_test)
Y_pred_test_cls = (model_joblib.predict(pred_x) > 0.5).astype("int32")
In [116]:
plt.figure(figsize=(2,2))
plt.imshow(pred_x.reshape(img_height,img_width,3)/255)
plt.show()
#print('Label - one hot encoded: \n',vggy_test_cat.iloc[30] )
print('Actual Label - one hot encoded: ', vggy_test[30])
print('Predicted Label - one hot encoded: ',Y_pred_test_cls[0] )
In [121]:
one_hot_encoder.inverse_transform(Y_pred_test_cls[0].reshape(1,-1))
Out[121]:
In [122]:
# Dumping the transformer to an external pickle file
joblib.dump(one_hot_encoder, 'VGG16_CNN_ohe.pkl')
Out[122]:
In [123]:
#Predicting from Pickle file
In [124]:
pkl_model=joblib.load('./Flower_Species_Classifier_VGG16_Augmented_100.pkl')
In [125]:
# Use the loaded model to make predictions
#model_joblib.predict(X_test)
Y_pred_test_cls = (pkl_model.predict(pred_x) > 0.5).astype("int32")
In [126]:
plt.figure(figsize=(2,2))
plt.imshow(pred_x.reshape(img_height,img_width,3)/255)
plt.show()
#print('Label - one hot encoded: \n',vggy_test_cat.iloc[30] )
print('Actual Label - one hot encoded: ', vggy_test[30])
print('Predicted Label - one hot encoded: ',Y_pred_test_cls[0] )
In [127]:
#Loading ppickeled encoder
ohe_pkl=joblib.load('./VGG16_CNN_ohe.pkl')
In [128]:
ohe_pkl.inverse_transform(Y_pred_test_cls[0].reshape(1,-1))
Out[128]:
Predictinng from Images directly from directory¶
In [1]:
from PIL import ImageTk, Image
import numpy as np
#from tkinter import filedialog
#import tkinter as tk
import tensorflow
from tensorflow.keras.preprocessing.image import img_to_array
from sklearn.externals import joblib
import matplotlib.pyplot as plt
%matplotlib inline
def predict_img(image_data):
#root = tk.Tk()
#image_data = filedialog.askopenfilename(initialdir="/", title="Choose an image",
# filetypes=(("all files", "*.*"), ("jpg files", "*.jpg"), ("png files", "*.png")))
original = Image.open(image_data)
plt.figure(figsize = (5,5))
plt.imshow(original)
original = original.resize((100, 100), Image.ANTIALIAS)
numpy_image = img_to_array(original)
#expanding dimensions as model is expecting a array of image not just a single image
image_batch = np.expand_dims(numpy_image, axis=0)
processed_image=image_batch/255
#Loading Pickled Model , we could have used Keras approach as well but we are going ahead with Pickle for now
vgg_cnn_model =joblib.load('./Flower_Species_Classifier_VGG16_Augmented_100.pkl')
#Loading pickeled encoder for reverse transforming output
ohe_pkl=joblib.load('./VGG16_CNN_ohe.pkl')
#Using the pickeled model for classification
predictions = vgg_cnn_model.predict(processed_image)
#inverse transforming the prediction for folder name details
label = ohe_pkl.inverse_transform(predictions.reshape(1,-1))
print("Predicted label for the Image: ",label)
#root.quit()
#root.destroy()
In [2]:
#test path -->> F:\GreatLearning\AI\ComputerVision\Project\Flowers-Classification\Test\0.jpg
predict_img('F:\\GreatLearning\\AI\\ComputerVision\\Project\\Flowers-Classification\\Test\\0.jpg')
In [3]:
predict_img('F:\\GreatLearning\\AI\\ComputerVision\\Project\\Flowers-Classification\\Test\\1.jpg')
- Creating separate jupyter notebook for UI to keep things modular & validate the pickle files can cork independently
In [ ]:
Observations¶
- For a detailed observations we can refer my existing details on ML Models/NN/CNN variations and we can add the benefits that a pretrained model is bringing to the picture- Copied below from Part 2 of project
we have to divide the models into two major groups:
- Machine learning Algorithms
- Deep Neural Networks (NN & CNN)
Machine Learning Algorithms:
- these algo's learn their mapping from provided input and output i.e. alog learns a function with diff sets of weight which help in predicting the accurate values.
- For classification algorithms they learns from the term being used "Decision Boundries"
- These decision boundries determine wether a new point belongs to which class or groups
- Decision boundries could vary from linear to non-linear and these algo's are very strong to identify any relationship and map it with proper function and weight.
- Image classification althoug a classification problem but it has much more details and relationships which ML Decision boundries are not able to map and replicate without very high computation and some times even thats not enough and becomme impossible for usinng these algos.
Deep Neural Netowrks ( ANN & CNN ):
- Deep Neural networks brought in a different concept called Feature Engineering
- Feature Extraction
- Feature Selection
- In feature extraction, we extract all the required features for our problem statement
- In feature selection, we select the important features that improve the performance of our deep learning model.
- By this design change in model is giving us huge advantage over Machine learning algorithms for identifying important features of the image and relationships with outputs which helps in categorizing/predictiong classes more accurately.
- Deep Neural networks brought in a different concept called Feature Engineering
Chalanges for Neural Network:
- NN amount of weight become unmanagable becuse it uses one perceptron for each input/pixel
- too many parameters as its fully connected
- each node is connected to previous and next layer making it very dense and many connections are redundant
- Translation Invariant - NN behaves differently to shifted version of same image/zoomed/inverted. To make it learn all those you have to feed all varaions of data, which is higly difficult.
- NN expects an identified object should appear on that specific place only which is never the real world scenario.
- spatial information is lost when the image is flattened(matrix to vector)
- This will make image processing difficult as the model will tend to overfit and capture unnecessary relationship
CNN Advantages:
- Convolution:
- feed forward NN wont see any order in their inputs
- CNN on other hand is better at dealing with multiple kinds of spatial deformations. It take advantage of local spatial coherence of images.
- This means that they are able to reduce dramatically the number of operation needed to process an image by using convolution on patches of adjacent pixels, because adjacent pixels together are meaningful.
- We also call that local connectivity.
- convolution in neural networks is operation of finding patterns. It has kernel that with which it basically scan an image and place where kernel have 100% match is a place where pattern matched.
- Pooling layers:
- downscale the image
- This is possible because we retain throughout the network, features that are organized spatially like an image, and thus downscaling them makes sense as reducing the size of the image.
- Convolution:
Pretrained Models observations compared with DNN/CNN¶
- Deep Nueral networks:
- A DNN works very well for classification and regression but it may not perform well with image classification, as we noticed in our models as well
- We were not able to improve the model performance significantly even after working with multiple factors like
- adding more layers
- diff optimizers
- no. of epochs
- amount of data
- Convolutional Neural Network:
- Convolution layers are very successful in tasks involving images classification, object identification, face recognition etc.
- They allow parameter sharing which results in a very optimized network compared to using Dense layers. This reduces the model commplexity as well the training time.
- Transfer Learning:
- "Transfer learning is a machine learning method where a model developed for a task is reused as the starting point for a model on a second task."
- "In transfer learning, we first train a base network on a base dataset and task, and then we repurpose the learned features, or transfer them, to a second target network to be trained on a target dataset and task. This process will tend to work if the features are general, meaning suitable to both base and target tasks, instead of specific to the base task."
- idea is to use a state of the art model which is already trained on a larger dataset for long time and proven to work well in related task
- using transfer learning we could train a model which have Test set accuracy of 90% in only 12 mins which is much better when compared to earlier models.
- We can further increase the accuracy by using
- More data/augmentation
- More epochs/training steps
- Adding more layers
- More regularization.
In [ ]:
In [ ]:
In [ ]:
- Reference
- https://www.analyticsvidhya.com/blog/2020/08/top-4-pre-trained-models-for-image-classification-with-python-code/
- https://machinelearningmastery.com/transfer-learning-for-deep-learning/#:~:text=Transfer%20learning%20is%20a%20machine,model%20on%20a%20second%20task.&text=Common%20examples%20of%20transfer%20learning,your%20own%20predictive%20modeling%20problems.
- https://towardsdatascience.com/a-comprehensive-hands-on-guide-to-transfer-learning-with-real-world-applications-in-deep-learning-212bf3b2f27a
In [ ]: